#include "argumentsType.h"
#include "IVisitor.h"

argumentsType::argumentsType(const ExprTypeList& args, const NameTokPtr& vararg, const NameTokPtr& kwarg, const ExprTypeList& defaults, const ExprTypeList& kwonlyargs, const ExprTypeList& kw_defaults, const ExprTypeList& annotation, const exprTypePtr& varargannotation, const exprTypePtr& kwargannotation, const ExprTypeList& kwonlyargannotation, int nodeId):
    SimpleNode(nodeId),
    _args(args),
    _vararg(vararg),
    _kwarg(kwarg),
    _defaults(defaults),
    _kwonlyargs(kwonlyargs),
    _kw_defaults(kw_defaults),
    _annotation(annotation),
    _varargannotation(varargannotation),
    _kwargannotation(kwargannotation),
    _kwonlyargannotation(kwonlyargannotation)
{
}
    
argumentsType::~argumentsType()
{
    _args.clear();_defaults.clear();_kwonlyargs.clear();_kw_defaults.clear();_annotation.clear();_kwonlyargannotation.clear();
}
    
Ast::AstTypes argumentsType::type() const
{
    return Ast::argumentsType;
}
    

ExprTypeList argumentsType::args()
{
    return _args;
}

void argumentsType::setArgs(const ExprTypeList& args)
{
    _args = args;
}

NameTokPtr argumentsType::vararg()
{
    return _vararg;
}

void argumentsType::setVararg(const NameTokPtr& vararg)
{
    _vararg = vararg;
}

NameTokPtr argumentsType::kwarg()
{
    return _kwarg;
}

void argumentsType::setKwarg(const NameTokPtr& kwarg)
{
    _kwarg = kwarg;
}

ExprTypeList argumentsType::defaults()
{
    return _defaults;
}

void argumentsType::setDefaults(const ExprTypeList& defaults)
{
    _defaults = defaults;
}

ExprTypeList argumentsType::kwonlyargs()
{
    return _kwonlyargs;
}

void argumentsType::setKwonlyargs(const ExprTypeList& kwonlyargs)
{
    _kwonlyargs = kwonlyargs;
}

ExprTypeList argumentsType::kw_defaults()
{
    return _kw_defaults;
}

void argumentsType::setKw_defaults(const ExprTypeList& kw_defaults)
{
    _kw_defaults = kw_defaults;
}

ExprTypeList argumentsType::annotation()
{
    return _annotation;
}

void argumentsType::setAnnotation(const ExprTypeList& annotation)
{
    _annotation = annotation;
}

exprTypePtr argumentsType::varargannotation()
{
    return _varargannotation;
}

void argumentsType::setVarargannotation(const exprTypePtr& varargannotation)
{
    _varargannotation = varargannotation;
}

exprTypePtr argumentsType::kwargannotation()
{
    return _kwargannotation;
}

void argumentsType::setKwargannotation(const exprTypePtr& kwargannotation)
{
    _kwargannotation = kwargannotation;
}

ExprTypeList argumentsType::kwonlyargannotation()
{
    return _kwonlyargannotation;
}

void argumentsType::setKwonlyargannotation(const ExprTypeList& kwonlyargannotation)
{
    _kwonlyargannotation = kwonlyargannotation;
}

    
QString argumentsType::toString() const
{
    return QString("argumentsType[args=%1, vararg=%2, kwarg=%3, defaults=%4, kwonlyargs=%5, kw_defaults=%6, annotation=%7, varargannotation=%8, kwargannotation=%9, kwonlyargannotation=%10]").
                arg(_args.toString()).
                arg(_vararg ? _vararg->toString():"").
                arg(_kwarg ? _kwarg->toString():"").
                arg(_defaults.toString()).
                arg(_kwonlyargs.toString()).
                arg(_kw_defaults.toString()).
                arg(_annotation.toString()).
                arg(_varargannotation ? _varargannotation->toString():"").
                arg(_kwargannotation ? _kwargannotation->toString():"").
                arg(_kwonlyargannotation.toString());
}
    
void argumentsType::accept(IVisitor* visitor, const SimpleNodePtr& node)
{
    traverse(visitor);
}
    
void argumentsType::traverse(IVisitor* visitor)
{
    _args.traverse(visitor);
    if (_vararg != NULL)
        _vararg->accept(visitor, _vararg);
    if (_kwarg != NULL)
        _kwarg->accept(visitor, _kwarg);
    _defaults.traverse(visitor);
    _kwonlyargs.traverse(visitor);
    _kw_defaults.traverse(visitor);
    _annotation.traverse(visitor);
    if (_varargannotation != NULL)
        _varargannotation->accept(visitor, _varargannotation);
    if (_kwargannotation != NULL)
        _kwargannotation->accept(visitor, _kwargannotation);
    _kwonlyargannotation.traverse(visitor);
}